home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 5 / Apprentice-Release5.iso / Source Code / C / Applications / Flex-CW 2.5.1 / y.tab.c < prev   
Text File  |  1995-06-12  |  36KB  |  1,446 lines
  1. #ifndef lint
  2. static char yysccsid[] = "@(#)yaccpar    1.9 (Berkeley) 02/21/93";
  3. #endif
  4. #define YYBYACC 1
  5. #define YYMAJOR 1
  6. #define YYMINOR 9
  7. #define yyclearin (yychar=(-1))
  8. #define yyerrok (yyerrflag=0)
  9. #define YYRECOVERING (yyerrflag!=0)
  10. #define YYPREFIX "yy"
  11. #line 10 "parse.y"
  12. /*-
  13.  * Copyright (c) 1990 The Regents of the University of California.
  14.  * All rights reserved.
  15.  *
  16.  * This code is derived from software contributed to Berkeley by
  17.  * Vern Paxson.
  18.  * 
  19.  * The United States Government has rights in this work pursuant
  20.  * to contract no. DE-AC03-76SF00098 between the United States
  21.  * Department of Energy and the University of California.
  22.  *
  23.  * Redistribution and use in source and binary forms are permitted provided
  24.  * that: (1) source distributions retain this entire copyright notice and
  25.  * comment, and (2) distributions including binaries display the following
  26.  * acknowledgement:  ``This product includes software developed by the
  27.  * University of California, Berkeley and its contributors'' in the
  28.  * documentation or other materials provided with the distribution and in
  29.  * all advertising materials mentioning features or use of this software.
  30.  * Neither the name of the University nor the names of its contributors may
  31.  * be used to endorse or promote products derived from this software without
  32.  * specific prior written permission.
  33.  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED
  34.  * WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
  35.  * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
  36.  */
  37.  
  38. /* $Header: /home/daffy/u0/vern/flex/RCS/parse.y,v 2.26 95/03/05 20:37:32 vern Exp $ */
  39.  
  40.  
  41. /* Some versions of bison are broken in that they use alloca() but don't
  42.  * declare it properly.  The following is the patented (just kidding!)
  43.  * #ifdef chud to fix the problem, courtesy of Francois Pinard.
  44.  */
  45. #ifdef YYBISON
  46. /* AIX requires this to be the first thing in the file.  */
  47. #ifdef __GNUC__
  48. #define alloca __builtin_alloca
  49. #else /* not __GNUC__ */
  50. #if HAVE_ALLOCA_H
  51. #include <alloca.h>
  52. #else /* not HAVE_ALLOCA_H */
  53. #ifdef _AIX
  54.  #pragma alloca
  55. #else /* not _AIX */
  56. #ifdef __hpux
  57. void *alloca ();
  58. #else /* not __hpux */
  59. #ifdef __TURBOC__
  60. #include <malloc.h>
  61. #else
  62. char *alloca ();
  63. #endif /* not __TURBOC__ */
  64. #endif /* not __hpux */
  65. #endif /* not _AIX */
  66. #endif /* not HAVE_ALLOCA_H */
  67. #endif /* not __GNUC__ */
  68. #endif /* YYBISON */
  69.  
  70. /* Bletch, ^^^^ that was ugly! */
  71.  
  72.  
  73. #include "flexdef.h"
  74.  
  75. int pat, scnum, eps, headcnt, trailcnt, anyccl, lastchar, i, rulelen;
  76. int trlcontxt, xcluflg, currccl, cclsorted, varlength, variable_trail_rule;
  77.  
  78. int *scon_stk;
  79. int scon_stk_ptr;
  80.  
  81. static int madeany = false;  /* whether we've made the '.' character class */
  82. int previous_continued_action;    /* whether the previous rule's action was '|' */
  83.  
  84. /* Expand a POSIX character class expression. */
  85. #define CCL_EXPR(func) \
  86.     { \
  87.     int c; \
  88.     for ( c = 0; c < csize; ++c ) \
  89.         if ( isascii(c) && func(c) ) \
  90.             ccladd( currccl, c ); \
  91.     }
  92.  
  93. /* While POSIX defines isblank(), it's not ANSI C. */
  94. #define IS_BLANK(c) ((c) == ' ' || (c) == '\t')
  95.  
  96. /* On some over-ambitious machines, such as DEC Alpha's, the default
  97.  * token type is "long" instead of "int"; this leads to problems with
  98.  * declaring yylval in flexdef.h.  But so far, all the yacc's I've seen
  99.  * wrap their definitions of YYSTYPE with "#ifndef YYSTYPE"'s, so the
  100.  * following should ensure that the default token type is "int".
  101.  */
  102. #define YYSTYPE int
  103.  
  104. #line 105 "y.tab.c"
  105. #define CHAR 257
  106. #define NUMBER 258
  107. #define SECTEND 259
  108. #define SCDECL 260
  109. #define XSCDECL 261
  110. #define NAME 262
  111. #define PREVCCL 263
  112. #define EOF_OP 264
  113. #define OPTION_OP 265
  114. #define OPT_OUTFILE 266
  115. #define OPT_PREFIX 267
  116. #define OPT_YYCLASS 268
  117. #define CCE_ALNUM 269
  118. #define CCE_ALPHA 270
  119. #define CCE_BLANK 271
  120. #define CCE_CNTRL 272
  121. #define CCE_DIGIT 273
  122. #define CCE_GRAPH 274
  123. #define CCE_LOWER 275
  124. #define CCE_PRINT 276
  125. #define CCE_PUNCT 277
  126. #define CCE_SPACE 278
  127. #define CCE_UPPER 279
  128. #define CCE_XDIGIT 280
  129. #define YYERRCODE 256
  130. short yylhs[] = {                                        -1,
  131.     0,    1,    2,    2,    2,    2,    3,    6,    6,    7,
  132.     7,    7,    8,    9,    9,   10,   10,   10,    4,    4,
  133.     4,    5,   12,   12,   12,   12,   14,   11,   11,   11,
  134.    15,   15,   15,   16,   13,   13,   13,   13,   18,   18,
  135.    17,   19,   19,   20,   20,   20,   20,   20,   20,   20,
  136.    20,   20,   20,   20,   20,   21,   21,   23,   23,   23,
  137.    23,   24,   24,   24,   24,   24,   24,   24,   24,   24,
  138.    24,   24,   24,   22,   22,
  139. };
  140. short yylen[] = {                                         2,
  141.     5,    0,    3,    2,    0,    1,    1,    1,    1,    2,
  142.     1,    1,    2,    2,    0,    3,    3,    3,    5,    5,
  143.     0,    0,    2,    1,    1,    1,    0,    4,    3,    0,
  144.     3,    1,    1,    1,    2,    3,    2,    1,    3,    1,
  145.     2,    2,    1,    2,    2,    2,    6,    5,    4,    1,
  146.     1,    1,    3,    3,    1,    3,    4,    4,    2,    2,
  147.     0,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  148.     1,    1,    1,    2,    0,
  149. };
  150. short yydefred[] = {                                      2,
  151.     0,    0,    6,    0,    7,    8,    9,   15,   21,    0,
  152.     4,    0,    0,   12,   11,    0,    0,    0,    0,   14,
  153.     0,    1,    0,   10,    0,    0,    0,    0,    0,   21,
  154.     0,   16,   17,   18,   29,   33,   34,    0,   32,    0,
  155.    26,   55,   52,   25,    0,   50,   75,    0,    0,    0,
  156.    24,    0,    0,    0,    0,   51,   28,    0,   20,   23,
  157.     0,    0,   61,    0,   19,    0,   37,    0,   41,    0,
  158.     0,   44,   45,   46,   31,   74,   53,   54,    0,    0,
  159.    62,   63,   64,   65,   66,   67,   68,   69,   70,   71,
  160.    72,   73,   56,   60,   36,    0,    0,   57,    0,   49,
  161.     0,   58,    0,   48,   47,
  162. };
  163. short yydgoto[] = {                                       1,
  164.     2,    4,    9,   13,   22,   10,   16,   11,   12,   20,
  165.    23,   50,   51,   29,   38,   39,   52,   53,   54,   55,
  166.    56,   61,   64,   94,
  167. };
  168. short yysindex[] = {                                      0,
  169.     0, -235,    0, -191,    0,    0,    0,    0,    0, -207,
  170.     0, -215,  -18,    0,    0, -202,    4,   26,   32,    0,
  171.    41,    0,  -35,    0, -168, -166, -165,   38, -180,    0,
  172.   -30,    0,    0,    0,    0,    0,    0,  -16,    0,  -40,
  173.     0,    0,    0,    0,   -2,    0,    0,   -2,    8,   93,
  174.     0,   -2,  -25,   -2,   15,    0,    0, -153,    0,    0,
  175.   -27,  -26,    0,  -88,    0,  -23,    0,   -2,    0,   15,
  176.  -150,    0,    0,    0,    0,    0,    0,    0,   -3,   65,
  177.     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
  178.     0,    0,    0,    0,    0,   -2,  -21,    0, -145,    0,
  179.  -116,    0,  -12,    0,    0,
  180. };
  181. short yyrindex[] = {                                      0,
  182.     0, -188,    0,    0,    0,    0,    0,    0,    0,    0,
  183.     0, -154,    1,    0,    0, -140,    0,    0,    0,    0,
  184.  -176,    0,  -28,    0,    0,    0,    0,    0,    0,    0,
  185.     0,    0,    0,    0,    0,    0,    0,    0,    0,  -32,
  186.     0,    0,    0,    0,    0,    0,    0,    0,   22,    0,
  187.     0,    0,  106,    7,  -10,    0,    0,    0,    0,    0,
  188.     0,    0,    0,    0,    0,  108,    0,    0,    0,   -7,
  189.     0,    0,    0,    0,    0,    0,    0,    0,    0,   46,
  190.     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
  191.     0,    0,    0,    0,    0,    9,    0,    0,    0,    0,
  192.     0,    0,    0,    0,    0,
  193. };
  194. short yygindex[] = {                                      0,
  195.     0,    0,    0,   92,  100,    0,    0,    0,    0,    0,
  196.     0,    0,   81,    0,    0,   69,    0,   27,   60,  -29,
  197.     0,    0,   66,    0,
  198. };
  199. #define YYTABLESIZE 326
  200. short yytable[] = {                                      43,
  201.    22,   30,   42,   47,   93,   22,   77,   30,  104,   48,
  202.    67,   22,   95,   30,   78,   46,   40,   22,   39,   21,
  203.     3,   69,  101,   43,   70,   43,   42,   58,   42,   43,
  204.    43,   47,   42,   42,   30,   43,   43,   48,   42,   42,
  205.    30,   21,   40,   46,   39,   57,   30,   40,   14,   39,
  206.    17,   18,   19,   40,   15,   39,   72,   73,   30,   24,
  207.    49,   30,   22,   45,   25,   22,   70,    5,    6,    7,
  208.     5,    5,    5,    8,   62,   36,    5,   74,   66,   27,
  209.    43,   37,   28,   42,   59,   27,   26,   30,   49,   98,
  210.    30,   30,   27,   32,   30,   33,   34,   68,   68,   35,
  211.    68,   63,   65,  100,   13,   13,   13,   97,   37,   99,
  212.    13,  102,  105,   43,   61,   38,   42,   35,    3,    3,
  213.     3,   40,   31,   30,    3,   60,   75,   96,   79,    0,
  214.    40,    0,   39,    0,    0,    0,    0,   71,   59,    0,
  215.     0,  103,    0,    0,    0,    0,    0,    0,    0,    0,
  216.     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
  217.     0,    0,    0,    0,    0,    0,    0,    0,   80,    0,
  218.     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
  219.    81,   82,   83,   84,   85,   86,   87,   88,   89,   90,
  220.    91,   92,    0,    0,    0,    0,    0,    0,    0,    0,
  221.     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
  222.     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
  223.     0,    0,    0,   30,   30,   41,   42,   22,   22,   76,
  224.    30,   30,   43,   44,   22,   22,    0,    0,    0,    0,
  225.     0,    0,    0,    0,    0,    0,   43,    0,    0,   42,
  226.     0,    0,   43,   80,   42,   42,   30,   30,    0,    0,
  227.    43,    0,    0,   30,   30,   81,   82,   83,   84,   85,
  228.    86,   87,   88,   89,   90,   91,   92,    0,   61,    0,
  229.     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
  230.    61,   61,   61,   61,   61,   61,   61,   61,   61,   61,
  231.    61,   61,   59,    0,    0,    0,    0,    0,    0,    0,
  232.     0,    0,    0,    0,   59,   59,   59,   59,   59,   59,
  233.    59,   59,   59,   59,   59,   59,
  234. };
  235. short yycheck[] = {                                      10,
  236.     0,   34,   10,   34,   93,   34,   34,   40,  125,   40,
  237.    36,   40,   36,   46,   41,   46,   10,   46,   10,   60,
  238.   256,   47,   44,   34,   54,   36,   34,   44,   36,   40,
  239.    41,   34,   40,   41,   34,   46,   47,   40,   46,   47,
  240.    40,   60,   36,   46,   36,   62,   46,   41,  256,   41,
  241.   266,  267,  268,   47,  262,   47,   42,   43,   91,  262,
  242.    91,   94,   91,   94,   61,   94,   96,  259,  260,  261,
  243.   259,  260,  261,  265,   48,  256,  265,   63,   52,  256,
  244.    91,  262,   42,   91,  125,  262,   61,  123,   91,   93,
  245.   123,   91,   61,  262,   94,  262,  262,  124,  124,   62,
  246.   124,   94,   10,  125,  259,  260,  261,  258,  262,   45,
  247.   265,  257,  125,  124,   93,   10,  124,   10,  259,  260,
  248.   261,   30,   23,  123,  265,   45,   58,   68,   63,   -1,
  249.   124,   -1,  124,   -1,   -1,   -1,   -1,  123,   93,   -1,
  250.    -1,  258,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
  251.    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
  252.    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,  257,   -1,
  253.    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
  254.   269,  270,  271,  272,  273,  274,  275,  276,  277,  278,
  255.   279,  280,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
  256.    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
  257.    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
  258.    -1,   -1,   -1,  256,  257,  256,  257,  256,  257,  257,
  259.   263,  264,  263,  264,  263,  264,   -1,   -1,   -1,   -1,
  260.    -1,   -1,   -1,   -1,   -1,   -1,  257,   -1,   -1,  257,
  261.    -1,   -1,  263,  257,  257,  263,  256,  257,   -1,   -1,
  262.   263,   -1,   -1,  263,  264,  269,  270,  271,  272,  273,
  263.   274,  275,  276,  277,  278,  279,  280,   -1,  257,   -1,
  264.    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
  265.   269,  270,  271,  272,  273,  274,  275,  276,  277,  278,
  266.   279,  280,  257,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
  267.    -1,   -1,   -1,   -1,  269,  270,  271,  272,  273,  274,
  268.   275,  276,  277,  278,  279,  280,
  269. };
  270. #define YYFINAL 1
  271. #ifndef YYDEBUG
  272. #define YYDEBUG 0
  273. #endif
  274. #define YYMAXTOKEN 280
  275. #if YYDEBUG
  276. char *yyname[] = {
  277. "end-of-file",0,0,0,0,0,0,0,0,0,"'\\n'",0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
  278. 0,0,0,"'\"'",0,"'$'",0,0,0,"'('","')'","'*'","'+'","','","'-'","'.'","'/'",0,0,
  279. 0,0,0,0,0,0,0,0,0,0,"'<'","'='","'>'","'?'",0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
  280. 0,0,0,0,0,0,0,0,0,"'['",0,"']'","'^'",0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
  281. 0,0,0,0,0,0,0,"'{'","'|'","'}'",0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
  282. 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
  283. 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
  284. 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,"CHAR","NUMBER","SECTEND",
  285. "SCDECL","XSCDECL","NAME","PREVCCL","EOF_OP","OPTION_OP","OPT_OUTFILE",
  286. "OPT_PREFIX","OPT_YYCLASS","CCE_ALNUM","CCE_ALPHA","CCE_BLANK","CCE_CNTRL",
  287. "CCE_DIGIT","CCE_GRAPH","CCE_LOWER","CCE_PRINT","CCE_PUNCT","CCE_SPACE",
  288. "CCE_UPPER","CCE_XDIGIT",
  289. };
  290. char *yyrule[] = {
  291. "$accept : goal",
  292. "goal : initlex sect1 sect1end sect2 initforrule",
  293. "initlex :",
  294. "sect1 : sect1 startconddecl namelist1",
  295. "sect1 : sect1 options",
  296. "sect1 :",
  297. "sect1 : error",
  298. "sect1end : SECTEND",
  299. "startconddecl : SCDECL",
  300. "startconddecl : XSCDECL",
  301. "namelist1 : namelist1 NAME",
  302. "namelist1 : NAME",
  303. "namelist1 : error",
  304. "options : OPTION_OP optionlist",
  305. "optionlist : optionlist option",
  306. "optionlist :",
  307. "option : OPT_OUTFILE '=' NAME",
  308. "option : OPT_PREFIX '=' NAME",
  309. "option : OPT_YYCLASS '=' NAME",
  310. "sect2 : sect2 scon initforrule flexrule '\\n'",
  311. "sect2 : sect2 scon '{' sect2 '}'",
  312. "sect2 :",
  313. "initforrule :",
  314. "flexrule : '^' rule",
  315. "flexrule : rule",
  316. "flexrule : EOF_OP",
  317. "flexrule : error",
  318. "scon_stk_ptr :",
  319. "scon : '<' scon_stk_ptr namelist2 '>'",
  320. "scon : '<' '*' '>'",
  321. "scon :",
  322. "namelist2 : namelist2 ',' sconname",
  323. "namelist2 : sconname",
  324. "namelist2 : error",
  325. "sconname : NAME",
  326. "rule : re2 re",
  327. "rule : re2 re '$'",
  328. "rule : re '$'",
  329. "rule : re",
  330. "re : re '|' series",
  331. "re : series",
  332. "re2 : re '/'",
  333. "series : series singleton",
  334. "series : singleton",
  335. "singleton : singleton '*'",
  336. "singleton : singleton '+'",
  337. "singleton : singleton '?'",
  338. "singleton : singleton '{' NUMBER ',' NUMBER '}'",
  339. "singleton : singleton '{' NUMBER ',' '}'",
  340. "singleton : singleton '{' NUMBER '}'",
  341. "singleton : '.'",
  342. "singleton : fullccl",
  343. "singleton : PREVCCL",
  344. "singleton : '\"' string '\"'",
  345. "singleton : '(' re ')'",
  346. "singleton : CHAR",
  347. "fullccl : '[' ccl ']'",
  348. "fullccl : '[' '^' ccl ']'",
  349. "ccl : ccl CHAR '-' CHAR",
  350. "ccl : ccl CHAR",
  351. "ccl : ccl ccl_expr",
  352. "ccl :",
  353. "ccl_expr : CCE_ALNUM",
  354. "ccl_expr : CCE_ALPHA",
  355. "ccl_expr : CCE_BLANK",
  356. "ccl_expr : CCE_CNTRL",
  357. "ccl_expr : CCE_DIGIT",
  358. "ccl_expr : CCE_GRAPH",
  359. "ccl_expr : CCE_LOWER",
  360. "ccl_expr : CCE_PRINT",
  361. "ccl_expr : CCE_PUNCT",
  362. "ccl_expr : CCE_SPACE",
  363. "ccl_expr : CCE_UPPER",
  364. "ccl_expr : CCE_XDIGIT",
  365. "string : string CHAR",
  366. "string :",
  367. };
  368. #endif
  369. #ifndef YYSTYPE
  370. typedef int YYSTYPE;
  371. #endif
  372. #ifdef YYSTACKSIZE
  373. #undef YYMAXDEPTH
  374. #define YYMAXDEPTH YYSTACKSIZE
  375. #else
  376. #ifdef YYMAXDEPTH
  377. #define YYSTACKSIZE YYMAXDEPTH
  378. #else
  379. #define YYSTACKSIZE 500
  380. #define YYMAXDEPTH 500
  381. #endif
  382. #endif
  383. int yydebug;
  384. int yynerrs;
  385. int yyerrflag;
  386. int yychar;
  387. short *yyssp;
  388. YYSTYPE *yyvsp;
  389. YYSTYPE yyval;
  390. YYSTYPE yylval;
  391. short yyss[YYSTACKSIZE];
  392. YYSTYPE yyvs[YYSTACKSIZE];
  393. #define yystacksize YYSTACKSIZE
  394. #line 769 "parse.y"
  395.  
  396.  
  397. /* build_eof_action - build the "<<EOF>>" action for the active start
  398.  *                    conditions
  399.  */
  400.  
  401. void build_eof_action()
  402.     {
  403.     register int i;
  404.     char action_text[MAXLINE];
  405.  
  406.     for ( i = 1; i <= scon_stk_ptr; ++i )
  407.         {
  408.         if ( sceof[scon_stk[i]] )
  409.             format_pinpoint_message(
  410.                 "multiple <<EOF>> rules for start condition %s",
  411.                 scname[scon_stk[i]] );
  412.  
  413.         else
  414.             {
  415.             sceof[scon_stk[i]] = true;
  416.             sprintf( action_text, "case YY_STATE_EOF(%s):\n",
  417.                 scname[scon_stk[i]] );
  418.             add_action( action_text );
  419.             }
  420.         }
  421.  
  422.     line_directive_out( (FILE *) 0, 1 );
  423.  
  424.     /* This isn't a normal rule after all - don't count it as
  425.      * such, so we don't have any holes in the rule numbering
  426.      * (which make generating "rule can never match" warnings
  427.      * more difficult.
  428.      */
  429.     --num_rules;
  430.     ++num_eof_rules;
  431.     }
  432.  
  433.  
  434. /* format_synerr - write out formatted syntax error */
  435.  
  436. void format_synerr( msg, arg )
  437. char msg[], arg[];
  438.     {
  439.     char errmsg[MAXLINE];
  440.  
  441.     (void) sprintf( errmsg, msg, arg );
  442.     synerr( errmsg );
  443.     }
  444.  
  445.  
  446. /* synerr - report a syntax error */
  447.  
  448. void synerr( str )
  449. char str[];
  450.     {
  451.     syntaxerror = true;
  452.     pinpoint_message( str );
  453.     }
  454.  
  455.  
  456. /* format_warn - write out formatted warning */
  457.  
  458. void format_warn( msg, arg )
  459. char msg[], arg[];
  460.     {
  461.     char warn_msg[MAXLINE];
  462.  
  463.     (void) sprintf( warn_msg, msg, arg );
  464.     warn( warn_msg );
  465.     }
  466.  
  467.  
  468. /* warn - report a warning, unless -w was given */
  469.  
  470. void warn( str )
  471. char str[];
  472.     {
  473.     line_warning( str, linenum );
  474.     }
  475.  
  476. /* format_pinpoint_message - write out a message formatted with one string,
  477.  *                 pinpointing its location
  478.  */
  479.  
  480. void format_pinpoint_message( msg, arg )
  481. char msg[], arg[];
  482.     {
  483.     char errmsg[MAXLINE];
  484.  
  485.     (void) sprintf( errmsg, msg, arg );
  486.     pinpoint_message( errmsg );
  487.     }
  488.  
  489.  
  490. /* pinpoint_message - write out a message, pinpointing its location */
  491.  
  492. void pinpoint_message( str )
  493. char str[];
  494.     {
  495.     line_pinpoint( str, linenum );
  496.     }
  497.  
  498.  
  499. /* line_warning - report a warning at a given line, unless -w was given */
  500.  
  501. void line_warning( str, line )
  502. char str[];
  503. int line;
  504.     {
  505.     char warning[MAXLINE];
  506.  
  507.     if ( ! nowarn )
  508.         {
  509.         sprintf( warning, "warning, %s", str );
  510.         line_pinpoint( warning, line );
  511.         }
  512.     }
  513.  
  514.  
  515. /* line_pinpoint - write out a message, pinpointing it at the given line */
  516.  
  517. void line_pinpoint( str, line )
  518. char str[];
  519. int line;
  520.     {
  521.     fprintf( stderr, "\"%s\", line %d: %s\n", infilename, line, str );
  522.     }
  523.  
  524.  
  525. /* yyerror - eat up an error message from the parser;
  526.  *         currently, messages are ignore
  527.  */
  528.  
  529. void yyerror( msg )
  530. char msg[];
  531.     {
  532.     }
  533. #line 534 "y.tab.c"
  534. #define YYABORT goto yyabort
  535. #define YYREJECT goto yyabort
  536. #define YYACCEPT goto yyaccept
  537. #define YYERROR goto yyerrlab
  538. int
  539. yyparse()
  540. {
  541.     register int yym, yyn, yystate;
  542. #if YYDEBUG
  543.     register char *yys;
  544.     extern char *getenv();
  545.  
  546.     if (yys = getenv("YYDEBUG"))
  547.     {
  548.         yyn = *yys;
  549.         if (yyn >= '0' && yyn <= '9')
  550.             yydebug = yyn - '0';
  551.     }
  552. #endif
  553.  
  554.     yynerrs = 0;
  555.     yyerrflag = 0;
  556.     yychar = (-1);
  557.  
  558.     yyssp = yyss;
  559.     yyvsp = yyvs;
  560.     *yyssp = yystate = 0;
  561.  
  562. yyloop:
  563.     if ((yyn = yydefred[yystate])!=0) goto yyreduce;
  564.     if (yychar < 0)
  565.     {
  566.         if ((yychar = yylex()) < 0) yychar = 0;
  567. #if YYDEBUG
  568.         if (yydebug)
  569.         {
  570.             yys = 0;
  571.             if (yychar <= YYMAXTOKEN) yys = yyname[yychar];
  572.             if (!yys) yys = "illegal-symbol";
  573.             printf("%sdebug: state %d, reading %d (%s)\n",
  574.                     YYPREFIX, yystate, yychar, yys);
  575.         }
  576. #endif
  577.     }
  578.     if (((yyn = yysindex[yystate])!=0) && (yyn += yychar) >= 0 &&
  579.             yyn <= YYTABLESIZE && yycheck[yyn] == yychar)
  580.     {
  581. #if YYDEBUG
  582.         if (yydebug)
  583.             printf("%sdebug: state %d, shifting to state %d\n",
  584.                     YYPREFIX, yystate, yytable[yyn]);
  585. #endif
  586.         if (yyssp >= yyss + yystacksize - 1)
  587.         {
  588.             goto yyoverflow;
  589.         }
  590.         *++yyssp = yystate = yytable[yyn];
  591.         *++yyvsp = yylval;
  592.         yychar = (-1);
  593.         if (yyerrflag > 0)  --yyerrflag;
  594.         goto yyloop;
  595.     }
  596.     if (((yyn = yyrindex[yystate])!=0) && (yyn += yychar) >= 0 &&
  597.             yyn <= YYTABLESIZE && yycheck[yyn] == yychar)
  598.     {
  599.         yyn = yytable[yyn];
  600.         goto yyreduce;
  601.     }
  602.     if (yyerrflag) goto yyinrecovery;
  603. #ifdef lint
  604.     goto yynewerror;
  605. #endif
  606. yynewerror:
  607.     yyerror("syntax error");
  608. #ifdef lint
  609.     goto yyerrlab;
  610. #endif
  611. yyerrlab:
  612.     ++yynerrs;
  613. yyinrecovery:
  614.     if (yyerrflag < 3)
  615.     {
  616.         yyerrflag = 3;
  617.         for (;;)
  618.         {
  619.             if (((yyn = yysindex[*yyssp])!=0) && (yyn += YYERRCODE) >= 0 &&
  620.                     yyn <= YYTABLESIZE && yycheck[yyn] == YYERRCODE)
  621.             {
  622. #if YYDEBUG
  623.                 if (yydebug)
  624.                     printf("%sdebug: state %d, error recovery shifting\
  625.  to state %d\n", YYPREFIX, *yyssp, yytable[yyn]);
  626. #endif
  627.                 if (yyssp >= yyss + yystacksize - 1)
  628.                 {
  629.                     goto yyoverflow;
  630.                 }
  631.                 *++yyssp = yystate = yytable[yyn];
  632.                 *++yyvsp = yylval;
  633.                 goto yyloop;
  634.             }
  635.             else
  636.             {
  637. #if YYDEBUG
  638.                 if (yydebug)
  639.                     printf("%sdebug: error recovery discarding state %d\n",
  640.                             YYPREFIX, *yyssp);
  641. #endif
  642.                 if (yyssp <= yyss) goto yyabort;
  643.                 --yyssp;
  644.                 --yyvsp;
  645.             }
  646.         }
  647.     }
  648.     else
  649.     {
  650.         if (yychar == 0) goto yyabort;
  651. #if YYDEBUG
  652.         if (yydebug)
  653.         {
  654.             yys = 0;
  655.             if (yychar <= YYMAXTOKEN) yys = yyname[yychar];
  656.             if (!yys) yys = "illegal-symbol";
  657.             printf("%sdebug: state %d, error recovery discards token %d (%s)\n",
  658.                     YYPREFIX, yystate, yychar, yys);
  659.         }
  660. #endif
  661.         yychar = (-1);
  662.         goto yyloop;
  663.     }
  664. yyreduce:
  665. #if YYDEBUG
  666.     if (yydebug)
  667.         printf("%sdebug: state %d, reducing by rule %d (%s)\n",
  668.                 YYPREFIX, yystate, yyn, yyrule[yyn]);
  669. #endif
  670.     yym = yylen[yyn];
  671.     yyval = yyvsp[1-yym];
  672.     switch (yyn)
  673.     {
  674. case 1:
  675. #line 106 "parse.y"
  676. { /* add default rule */
  677.             int def_rule;
  678.  
  679.             pat = cclinit();
  680.             cclnegate( pat );
  681.  
  682.             def_rule = mkstate( -pat );
  683.  
  684.             /* Remember the number of the default rule so we
  685.              * don't generate "can't match" warnings for it.
  686.              */
  687.             default_rule = num_rules;
  688.  
  689.             finish_rule( def_rule, false, 0, 0 );
  690.  
  691.             for ( i = 1; i <= lastsc; ++i )
  692.                 scset[i] = mkbranch( scset[i], def_rule );
  693.  
  694.             if ( spprdflt )
  695.                 add_action(
  696.                 "YY_FATAL_ERROR( \"flex scanner jammed\" )" );
  697.             else
  698.                 add_action( "ECHO" );
  699.  
  700.             add_action( ";\n\tYY_BREAK\n" );
  701.             }
  702. break;
  703. case 2:
  704. #line 135 "parse.y"
  705. { /* initialize for processing rules */
  706.  
  707.             /* Create default DFA start condition. */
  708.             scinstal( "INITIAL", false );
  709.             }
  710. break;
  711. case 6:
  712. #line 146 "parse.y"
  713. { synerr( "unknown error processing section 1" ); }
  714. break;
  715. case 7:
  716. #line 150 "parse.y"
  717. {
  718.             check_options();
  719.             scon_stk = allocate_integer_array( lastsc + 1 );
  720.             scon_stk_ptr = 0;
  721.             }
  722. break;
  723. case 8:
  724. #line 158 "parse.y"
  725. { xcluflg = false; }
  726. break;
  727. case 9:
  728. #line 161 "parse.y"
  729. { xcluflg = true; }
  730. break;
  731. case 10:
  732. #line 165 "parse.y"
  733. { scinstal( nmstr, xcluflg ); }
  734. break;
  735. case 11:
  736. #line 168 "parse.y"
  737. { scinstal( nmstr, xcluflg ); }
  738. break;
  739. case 12:
  740. #line 171 "parse.y"
  741. { synerr( "bad start condition list" ); }
  742. break;
  743. case 16:
  744. #line 182 "parse.y"
  745. {
  746.             outfilename = copy_string( nmstr );
  747.             did_outfilename = 1;
  748.             }
  749. break;
  750. case 17:
  751. #line 187 "parse.y"
  752. { prefix = copy_string( nmstr ); }
  753. break;
  754. case 18:
  755. #line 189 "parse.y"
  756. { yyclass = copy_string( nmstr ); }
  757. break;
  758. case 19:
  759. #line 193 "parse.y"
  760. { scon_stk_ptr = yyvsp[-3]; }
  761. break;
  762. case 20:
  763. #line 195 "parse.y"
  764. { scon_stk_ptr = yyvsp[-3]; }
  765. break;
  766. case 22:
  767. #line 200 "parse.y"
  768. {
  769.             /* Initialize for a parse of one rule. */
  770.             trlcontxt = variable_trail_rule = varlength = false;
  771.             trailcnt = headcnt = rulelen = 0;
  772.             current_state_type = STATE_NORMAL;
  773.             previous_continued_action = continued_action;
  774.             in_rule = true;
  775.  
  776.             new_rule();
  777.             }
  778. break;
  779. case 23:
  780. #line 213 "parse.y"
  781. {
  782.             pat = yyvsp[0];
  783.             finish_rule( pat, variable_trail_rule,
  784.                 headcnt, trailcnt );
  785.  
  786.             if ( scon_stk_ptr > 0 )
  787.                 {
  788.                 for ( i = 1; i <= scon_stk_ptr; ++i )
  789.                     scbol[scon_stk[i]] =
  790.                         mkbranch( scbol[scon_stk[i]],
  791.                                 pat );
  792.                 }
  793.  
  794.             else
  795.                 {
  796.                 /* Add to all non-exclusive start conditions,
  797.                  * including the default (0) start condition.
  798.                  */
  799.  
  800.                 for ( i = 1; i <= lastsc; ++i )
  801.                     if ( ! scxclu[i] )
  802.                         scbol[i] = mkbranch( scbol[i],
  803.                                     pat );
  804.                 }
  805.  
  806.             if ( ! bol_needed )
  807.                 {
  808.                 bol_needed = true;
  809.  
  810.                 if ( performance_report > 1 )
  811.                     pinpoint_message(
  812.             "'^' operator results in sub-optimal performance" );
  813.                 }
  814.             }
  815. break;
  816. case 24:
  817. #line 249 "parse.y"
  818. {
  819.             pat = yyvsp[0];
  820.             finish_rule( pat, variable_trail_rule,
  821.                 headcnt, trailcnt );
  822.  
  823.             if ( scon_stk_ptr > 0 )
  824.                 {
  825.                 for ( i = 1; i <= scon_stk_ptr; ++i )
  826.                     scset[scon_stk[i]] =
  827.                         mkbranch( scset[scon_stk[i]],
  828.                                 pat );
  829.                 }
  830.  
  831.             else
  832.                 {
  833.                 for ( i = 1; i <= lastsc; ++i )
  834.                     if ( ! scxclu[i] )
  835.                         scset[i] =
  836.                             mkbranch( scset[i],
  837.                                 pat );
  838.                 }
  839.             }
  840. break;
  841. case 25:
  842. #line 273 "parse.y"
  843. {
  844.             if ( scon_stk_ptr > 0 )
  845.                 build_eof_action();
  846.     
  847.             else
  848.                 {
  849.                 /* This EOF applies to all start conditions
  850.                  * which don't already have EOF actions.
  851.                  */
  852.                 for ( i = 1; i <= lastsc; ++i )
  853.                     if ( ! sceof[i] )
  854.                         scon_stk[++scon_stk_ptr] = i;
  855.  
  856.                 if ( scon_stk_ptr == 0 )
  857.                     warn(
  858.             "all start conditions already have <<EOF>> rules" );
  859.  
  860.                 else
  861.                     build_eof_action();
  862.                 }
  863.             }
  864. break;
  865. case 26:
  866. #line 296 "parse.y"
  867. { synerr( "unrecognized rule" ); }
  868. break;
  869. case 27:
  870. #line 300 "parse.y"
  871. { yyval = scon_stk_ptr; }
  872. break;
  873. case 28:
  874. #line 304 "parse.y"
  875. { yyval = yyvsp[-2]; }
  876. break;
  877. case 29:
  878. #line 307 "parse.y"
  879. {
  880.             yyval = scon_stk_ptr;
  881.  
  882.             for ( i = 1; i <= lastsc; ++i )
  883.                 {
  884.                 int j;
  885.  
  886.                 for ( j = 1; j <= scon_stk_ptr; ++j )
  887.                     if ( scon_stk[j] == i )
  888.                         break;
  889.  
  890.                 if ( j > scon_stk_ptr )
  891.                     scon_stk[++scon_stk_ptr] = i;
  892.                 }
  893.             }
  894. break;
  895. case 30:
  896. #line 324 "parse.y"
  897. { yyval = scon_stk_ptr; }
  898. break;
  899. case 33:
  900. #line 332 "parse.y"
  901. { synerr( "bad start condition list" ); }
  902. break;
  903. case 34:
  904. #line 336 "parse.y"
  905. {
  906.             if ( (scnum = sclookup( nmstr )) == 0 )
  907.                 format_pinpoint_message(
  908.                     "undeclared start condition %s",
  909.                     nmstr );
  910.             else
  911.                 {
  912.                 for ( i = 1; i <= scon_stk_ptr; ++i )
  913.                     if ( scon_stk[i] == scnum )
  914.                         {
  915.                         format_warn(
  916.                             "<%s> specified twice",
  917.                             scname[scnum] );
  918.                         break;
  919.                         }
  920.  
  921.                 if ( i > scon_stk_ptr )
  922.                     scon_stk[++scon_stk_ptr] = scnum;
  923.                 }
  924.             }
  925. break;
  926. case 35:
  927. #line 359 "parse.y"
  928. {
  929.             if ( transchar[lastst[yyvsp[0]]] != SYM_EPSILON )
  930.                 /* Provide final transition \now/ so it
  931.                  * will be marked as a trailing context
  932.                  * state.
  933.                  */
  934.                 yyvsp[0] = link_machines( yyvsp[0],
  935.                         mkstate( SYM_EPSILON ) );
  936.  
  937.             mark_beginning_as_normal( yyvsp[0] );
  938.             current_state_type = STATE_NORMAL;
  939.  
  940.             if ( previous_continued_action )
  941.                 {
  942.                 /* We need to treat this as variable trailing
  943.                  * context so that the backup does not happen
  944.                  * in the action but before the action switch
  945.                  * statement.  If the backup happens in the
  946.                  * action, then the rules "falling into" this
  947.                  * one's action will *also* do the backup,
  948.                  * erroneously.
  949.                  */
  950.                 if ( ! varlength || headcnt != 0 )
  951.                     warn(
  952.         "trailing context made variable due to preceding '|' action" );
  953.  
  954.                 /* Mark as variable. */
  955.                 varlength = true;
  956.                 headcnt = 0;
  957.                 }
  958.  
  959.             if ( lex_compat || (varlength && headcnt == 0) )
  960.                 { /* variable trailing context rule */
  961.                 /* Mark the first part of the rule as the
  962.                  * accepting "head" part of a trailing
  963.                  * context rule.
  964.                  *
  965.                  * By the way, we didn't do this at the
  966.                  * beginning of this production because back
  967.                  * then current_state_type was set up for a
  968.                  * trail rule, and add_accept() can create
  969.                  * a new state ...
  970.                  */
  971.                 add_accept( yyvsp[-1],
  972.                     num_rules | YY_TRAILING_HEAD_MASK );
  973.                 variable_trail_rule = true;
  974.                 }
  975.             
  976.             else
  977.                 trailcnt = rulelen;
  978.  
  979.             yyval = link_machines( yyvsp[-1], yyvsp[0] );
  980.             }
  981. break;
  982. case 36:
  983. #line 414 "parse.y"
  984. { synerr( "trailing context used twice" ); }
  985. break;
  986. case 37:
  987. #line 417 "parse.y"
  988. {
  989.             headcnt = 0;
  990.             trailcnt = 1;
  991.             rulelen = 1;
  992.             varlength = false;
  993.  
  994.             current_state_type = STATE_TRAILING_CONTEXT;
  995.  
  996.             if ( trlcontxt )
  997.                 {
  998.                 synerr( "trailing context used twice" );
  999.                 yyval = mkstate( SYM_EPSILON );
  1000.                 }
  1001.  
  1002.             else if ( previous_continued_action )
  1003.                 {
  1004.                 /* See the comment in the rule for "re2 re"
  1005.                  * above.
  1006.                  */
  1007.                 warn(
  1008.         "trailing context made variable due to preceding '|' action" );
  1009.  
  1010.                 varlength = true;
  1011.                 }
  1012.  
  1013.             if ( lex_compat || varlength )
  1014.                 {
  1015.                 /* Again, see the comment in the rule for
  1016.                  * "re2 re" above.
  1017.                  */
  1018.                 add_accept( yyvsp[-1],
  1019.                     num_rules | YY_TRAILING_HEAD_MASK );
  1020.                 variable_trail_rule = true;
  1021.                 }
  1022.  
  1023.             trlcontxt = true;
  1024.  
  1025.             eps = mkstate( SYM_EPSILON );
  1026.             yyval = link_machines( yyvsp[-1],
  1027.                 link_machines( eps, mkstate( '\n' ) ) );
  1028.             }
  1029. break;
  1030. case 38:
  1031. #line 460 "parse.y"
  1032. {
  1033.             yyval = yyvsp[0];
  1034.  
  1035.             if ( trlcontxt )
  1036.                 {
  1037.                 if ( lex_compat || (varlength && headcnt == 0) )
  1038.                     /* Both head and trail are
  1039.                      * variable-length.
  1040.                      */
  1041.                     variable_trail_rule = true;
  1042.                 else
  1043.                     trailcnt = rulelen;
  1044.                 }
  1045.             }
  1046. break;
  1047. case 39:
  1048. #line 478 "parse.y"
  1049. {
  1050.             varlength = true;
  1051.             yyval = mkor( yyvsp[-2], yyvsp[0] );
  1052.             }
  1053. break;
  1054. case 40:
  1055. #line 484 "parse.y"
  1056. { yyval = yyvsp[0]; }
  1057. break;
  1058. case 41:
  1059. #line 489 "parse.y"
  1060. {
  1061.             /* This rule is written separately so the
  1062.              * reduction will occur before the trailing
  1063.              * series is parsed.
  1064.              */
  1065.  
  1066.             if ( trlcontxt )
  1067.                 synerr( "trailing context used twice" );
  1068.             else
  1069.                 trlcontxt = true;
  1070.  
  1071.             if ( varlength )
  1072.                 /* We hope the trailing context is
  1073.                  * fixed-length.
  1074.                  */
  1075.                 varlength = false;
  1076.             else
  1077.                 headcnt = rulelen;
  1078.  
  1079.             rulelen = 0;
  1080.  
  1081.             current_state_type = STATE_TRAILING_CONTEXT;
  1082.             yyval = yyvsp[-1];
  1083.             }
  1084. break;
  1085. case 42:
  1086. #line 516 "parse.y"
  1087. {
  1088.             /* This is where concatenation of adjacent patterns
  1089.              * gets done.
  1090.              */
  1091.             yyval = link_machines( yyvsp[-1], yyvsp[0] );
  1092.             }
  1093. break;
  1094. case 43:
  1095. #line 524 "parse.y"
  1096. { yyval = yyvsp[0]; }
  1097. break;
  1098. case 44:
  1099. #line 528 "parse.y"
  1100. {
  1101.             varlength = true;
  1102.  
  1103.             yyval = mkclos( yyvsp[-1] );
  1104.             }
  1105. break;
  1106. case 45:
  1107. #line 535 "parse.y"
  1108. {
  1109.             varlength = true;
  1110.             yyval = mkposcl( yyvsp[-1] );
  1111.             }
  1112. break;
  1113. case 46:
  1114. #line 541 "parse.y"
  1115. {
  1116.             varlength = true;
  1117.             yyval = mkopt( yyvsp[-1] );
  1118.             }
  1119. break;
  1120. case 47:
  1121. #line 547 "parse.y"
  1122. {
  1123.             varlength = true;
  1124.  
  1125.             if ( yyvsp[-3] > yyvsp[-1] || yyvsp[-3] < 0 )
  1126.                 {
  1127.                 synerr( "bad iteration values" );
  1128.                 yyval = yyvsp[-5];
  1129.                 }
  1130.             else
  1131.                 {
  1132.                 if ( yyvsp[-3] == 0 )
  1133.                     {
  1134.                     if ( yyvsp[-1] <= 0 )
  1135.                         {
  1136.                         synerr(
  1137.                         "bad iteration values" );
  1138.                         yyval = yyvsp[-5];
  1139.                         }
  1140.                     else
  1141.                         yyval = mkopt(
  1142.                             mkrep( yyvsp[-5], 1, yyvsp[-1] ) );
  1143.                     }
  1144.                 else
  1145.                     yyval = mkrep( yyvsp[-5], yyvsp[-3], yyvsp[-1] );
  1146.                 }
  1147.             }
  1148. break;
  1149. case 48:
  1150. #line 575 "parse.y"
  1151. {
  1152.             varlength = true;
  1153.  
  1154.             if ( yyvsp[-2] <= 0 )
  1155.                 {
  1156.                 synerr( "iteration value must be positive" );
  1157.                 yyval = yyvsp[-4];
  1158.                 }
  1159.  
  1160.             else
  1161.                 yyval = mkrep( yyvsp[-4], yyvsp[-2], INFINITY );
  1162.             }
  1163. break;
  1164. case 49:
  1165. #line 589 "parse.y"
  1166. {
  1167.             /* The singleton could be something like "(foo)",
  1168.              * in which case we have no idea what its length
  1169.              * is, so we punt here.
  1170.              */
  1171.             varlength = true;
  1172.  
  1173.             if ( yyvsp[-1] <= 0 )
  1174.                 {
  1175.                 synerr( "iteration value must be positive" );
  1176.                 yyval = yyvsp[-3];
  1177.                 }
  1178.  
  1179.             else
  1180.                 yyval = link_machines( yyvsp[-3],
  1181.                         copysingl( yyvsp[-3], yyvsp[-1] - 1 ) );
  1182.             }
  1183. break;
  1184. case 50:
  1185. #line 608 "parse.y"
  1186. {
  1187.             if ( ! madeany )
  1188.                 {
  1189.                 /* Create the '.' character class. */
  1190.                 anyccl = cclinit();
  1191.                 ccladd( anyccl, '\n' );
  1192.                 cclnegate( anyccl );
  1193.  
  1194.                 if ( useecs )
  1195.                     mkeccl( ccltbl + cclmap[anyccl],
  1196.                         ccllen[anyccl], nextecm,
  1197.                         ecgroup, csize, csize );
  1198.  
  1199.                 madeany = true;
  1200.                 }
  1201.  
  1202.             ++rulelen;
  1203.  
  1204.             yyval = mkstate( -anyccl );
  1205.             }
  1206. break;
  1207. case 51:
  1208. #line 630 "parse.y"
  1209. {
  1210.             if ( ! cclsorted )
  1211.                 /* Sort characters for fast searching.  We
  1212.                  * use a shell sort since this list could
  1213.                  * be large.
  1214.                  */
  1215.                 cshell( ccltbl + cclmap[yyvsp[0]], ccllen[yyvsp[0]], true );
  1216.  
  1217.             if ( useecs )
  1218.                 mkeccl( ccltbl + cclmap[yyvsp[0]], ccllen[yyvsp[0]],
  1219.                     nextecm, ecgroup, csize, csize );
  1220.  
  1221.             ++rulelen;
  1222.  
  1223.             yyval = mkstate( -yyvsp[0] );
  1224.             }
  1225. break;
  1226. case 52:
  1227. #line 648 "parse.y"
  1228. {
  1229.             ++rulelen;
  1230.  
  1231.             yyval = mkstate( -yyvsp[0] );
  1232.             }
  1233. break;
  1234. case 53:
  1235. #line 655 "parse.y"
  1236. { yyval = yyvsp[-1]; }
  1237. break;
  1238. case 54:
  1239. #line 658 "parse.y"
  1240. { yyval = yyvsp[-1]; }
  1241. break;
  1242. case 55:
  1243. #line 661 "parse.y"
  1244. {
  1245.             ++rulelen;
  1246.  
  1247.             if ( caseins && yyvsp[0] >= 'A' && yyvsp[0] <= 'Z' )
  1248.                 yyvsp[0] = clower( yyvsp[0] );
  1249.  
  1250.             yyval = mkstate( yyvsp[0] );
  1251.             }
  1252. break;
  1253. case 56:
  1254. #line 672 "parse.y"
  1255. { yyval = yyvsp[-1]; }
  1256. break;
  1257. case 57:
  1258. #line 675 "parse.y"
  1259. {
  1260.             cclnegate( yyvsp[-1] );
  1261.             yyval = yyvsp[-1];
  1262.             }
  1263. break;
  1264. case 58:
  1265. #line 682 "parse.y"
  1266. {
  1267.             if ( caseins )
  1268.                 {
  1269.                 if ( yyvsp[-2] >= 'A' && yyvsp[-2] <= 'Z' )
  1270.                     yyvsp[-2] = clower( yyvsp[-2] );
  1271.                 if ( yyvsp[0] >= 'A' && yyvsp[0] <= 'Z' )
  1272.                     yyvsp[0] = clower( yyvsp[0] );
  1273.                 }
  1274.  
  1275.             if ( yyvsp[-2] > yyvsp[0] )
  1276.                 synerr( "negative range in character class" );
  1277.  
  1278.             else
  1279.                 {
  1280.                 for ( i = yyvsp[-2]; i <= yyvsp[0]; ++i )
  1281.                     ccladd( yyvsp[-3], i );
  1282.  
  1283.                 /* Keep track if this ccl is staying in
  1284.                  * alphabetical order.
  1285.                  */
  1286.                 cclsorted = cclsorted && (yyvsp[-2] > lastchar);
  1287.                 lastchar = yyvsp[0];
  1288.                 }
  1289.  
  1290.             yyval = yyvsp[-3];
  1291.             }
  1292. break;
  1293. case 59:
  1294. #line 710 "parse.y"
  1295. {
  1296.             if ( caseins && yyvsp[0] >= 'A' && yyvsp[0] <= 'Z' )
  1297.                 yyvsp[0] = clower( yyvsp[0] );
  1298.  
  1299.             ccladd( yyvsp[-1], yyvsp[0] );
  1300.             cclsorted = cclsorted && (yyvsp[0] > lastchar);
  1301.             lastchar = yyvsp[0];
  1302.             yyval = yyvsp[-1];
  1303.             }
  1304. break;
  1305. case 60:
  1306. #line 721 "parse.y"
  1307. {
  1308.             /* Too hard to properly maintain cclsorted. */
  1309.             cclsorted = false;
  1310.             yyval = yyvsp[-1];
  1311.             }
  1312. break;
  1313. case 61:
  1314. #line 728 "parse.y"
  1315. {
  1316.             cclsorted = true;
  1317.             lastchar = 0;
  1318.             currccl = yyval = cclinit();
  1319.             }
  1320. break;
  1321. case 62:
  1322. #line 735 "parse.y"
  1323. { CCL_EXPR(isalnum) }
  1324. break;
  1325. case 63:
  1326. #line 736 "parse.y"
  1327. { CCL_EXPR(isalpha) }
  1328. break;
  1329. case 64:
  1330. #line 737 "parse.y"
  1331. { CCL_EXPR(IS_BLANK) }
  1332. break;
  1333. case 65:
  1334. #line 738 "parse.y"
  1335. { CCL_EXPR(iscntrl) }
  1336. break;
  1337. case 66:
  1338. #line 739 "parse.y"
  1339. { CCL_EXPR(isdigit) }
  1340. break;
  1341. case 67:
  1342. #line 740 "parse.y"
  1343. { CCL_EXPR(isgraph) }
  1344. break;
  1345. case 68:
  1346. #line 741 "parse.y"
  1347. { CCL_EXPR(islower) }
  1348. break;
  1349. case 69:
  1350. #line 742 "parse.y"
  1351. { CCL_EXPR(isprint) }
  1352. break;
  1353. case 70:
  1354. #line 743 "parse.y"
  1355. { CCL_EXPR(ispunct) }
  1356. break;
  1357. case 71:
  1358. #line 744 "parse.y"
  1359. { CCL_EXPR(isspace) }
  1360. break;
  1361. case 72:
  1362. #line 745 "parse.y"
  1363. {
  1364.                 if ( caseins )
  1365.                     CCL_EXPR(islower)
  1366.                 else
  1367.                     CCL_EXPR(isupper)
  1368.                 }
  1369. break;
  1370. case 73:
  1371. #line 751 "parse.y"
  1372. { CCL_EXPR(isxdigit) }
  1373. break;
  1374. case 74:
  1375. #line 755 "parse.y"
  1376. {
  1377.             if ( caseins && yyvsp[0] >= 'A' && yyvsp[0] <= 'Z' )
  1378.                 yyvsp[0] = clower( yyvsp[0] );
  1379.  
  1380.             ++rulelen;
  1381.  
  1382.             yyval = link_machines( yyvsp[-1], mkstate( yyvsp[0] ) );
  1383.             }
  1384. break;
  1385. case 75:
  1386. #line 765 "parse.y"
  1387. { yyval = mkstate( SYM_EPSILON ); }
  1388. break;
  1389. #line 1390 "y.tab.c"
  1390.     }
  1391.     yyssp -= yym;
  1392.     yystate = *yyssp;
  1393.     yyvsp -= yym;
  1394.     yym = yylhs[yyn];
  1395.     if (yystate == 0 && yym == 0)
  1396.     {
  1397. #if YYDEBUG
  1398.         if (yydebug)
  1399.             printf("%sdebug: after reduction, shifting from state 0 to\
  1400.  state %d\n", YYPREFIX, YYFINAL);
  1401. #endif
  1402.         yystate = YYFINAL;
  1403.         *++yyssp = YYFINAL;
  1404.         *++yyvsp = yyval;
  1405.         if (yychar < 0)
  1406.         {
  1407.             if ((yychar = yylex()) < 0) yychar = 0;
  1408. #if YYDEBUG
  1409.             if (yydebug)
  1410.             {
  1411.                 yys = 0;
  1412.                 if (yychar <= YYMAXTOKEN) yys = yyname[yychar];
  1413.                 if (!yys) yys = "illegal-symbol";
  1414.                 printf("%sdebug: state %d, reading %d (%s)\n",
  1415.                         YYPREFIX, YYFINAL, yychar, yys);
  1416.             }
  1417. #endif
  1418.         }
  1419.         if (yychar == 0) goto yyaccept;
  1420.         goto yyloop;
  1421.     }
  1422.     if (((yyn = yygindex[yym])!=0) && (yyn += yystate) >= 0 &&
  1423.             yyn <= YYTABLESIZE && yycheck[yyn] == yystate)
  1424.         yystate = yytable[yyn];
  1425.     else
  1426.         yystate = yydgoto[yym];
  1427. #if YYDEBUG
  1428.     if (yydebug)
  1429.         printf("%sdebug: after reduction, shifting from state %d \
  1430. to state %d\n", YYPREFIX, *yyssp, yystate);
  1431. #endif
  1432.     if (yyssp >= yyss + yystacksize - 1)
  1433.     {
  1434.         goto yyoverflow;
  1435.     }
  1436.     *++yyssp = yystate;
  1437.     *++yyvsp = yyval;
  1438.     goto yyloop;
  1439. yyoverflow:
  1440.     yyerror("yacc stack overflow");
  1441. yyabort:
  1442.     return (1);
  1443. yyaccept:
  1444.     return (0);
  1445. }
  1446.